// 如果 value 不是数组, 那么强制转为数组
// 空转为空数组 undefined | null | '' => []
// 1 => [1], false => [false], {} => [{}]
export function castArray(value: any) {
  if (Array.isArray(value)) {
    return value
  } else if (value === undefined || value === null || value === '') {
    return []
  } else {
    return [value]
  }
}
// 如果 value 不是数组, 那么强制转为数组
export function castFileList(value: any) {
  if (Array.isArray(value)) {
    return value
  } else if (value === undefined || value === null || value === '') {
    return []
  } else {
    return value.split(',')
  }
}
// 如果 value 不是字符串, 那么强制转为字符串
export function castString(value: any) {
  if (typeof value === 'string') {
    return value
  } else if (value === undefined || value === null) {
    return ''
  } else if (value.toString) {
    return value.toString()
  } else {
    return value + ''
  }
}
// 如果 value 不是Boolean, 那么强制转为Boolean
export function castBoolean(value: any) {
  if (typeof value === 'boolean') {
    return value
  } else {
    return Boolean(value)
  }
}
// 如果 value 不是Number, 那么强制转为Number
export function castNumber(value: any) {
  if (typeof value === 'number') {
    return value
  } else {
    return Number(value) || 0
  }
}

// 深拷贝
export function cloneDeep(target) {
  if(target === null) {    
    return target  
  }  
  if(target instanceof Date) {    
    return new Date(target.getTime())  
  }  
  if(target instanceof Array) {    
    const cp = [] as any[]    
    (target as any[]).forEach(v => cp.push(v))    
    return cp.map((n: any) =>cloneDeep(n)) as any  
  }  
  if(typeof target === 'object' && target !== {}) {    
    const cp = {...(target as {[key: string]: any})} as { [key: string]: any }    
    Object.keys(cp).forEach(k => {      
      cp[k] =cloneDeep(cp[k])    
    })    
    return cp
  }
};

/**
 * 节流原理：在一定时间内，只能触发一次
 *
 * @param {Function} func 要执行的回调函数
 * @param {Number} wait 延时的时间
 * @param {Boolean} immediate 是否立即执行
 * @return null
 */
 let time: any;
 let flag: boolean = false;
 export function throttle(wait: number, fnc: Function, immediate?: boolean) {
   if (immediate) {
     if (!flag) {
       flag = true;
       // 如果是立即执行，则在wait毫秒内开始时执行
       typeof fnc === "function" && fnc();
       time = setTimeout(() => {
         flag = false;
       }, wait);
     }
   } else {
     if (!flag) {
       flag = true;
       // 如果是非立即执行，则在wait毫秒内的结束处执行
       time = setTimeout(() => {
         typeof fnc === "function" && fnc();
         flag = false;
       }, wait);
     }
   }
 }
 
 /**
  * 防抖原理：一定时间内，只有最后一次操作，再过wait毫秒后才执行函数
  *
  * @param {Function} func 要执行的回调函数
  * @param {Number} wait 延时的时间
  * @return null
  */
 let timeout: any = null;
 export function debounce(fnc: Function, wait: number) {
   if (timeout) {
     clearTimeout(timeout);
     timeout = null;
   }
   timeout = setTimeout(() => {
     typeof fnc === "function" && fnc();
     clearTimeout(timeout);
   }, wait);
 };
 